home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
CD ROM Paradise Collection 4
/
CD ROM Paradise Collection 4 1995 Nov.iso
/
program
/
swags_z.zip
/
STRINGS.SWG
/
0093_Basm routines.pas
< prev
next >
Wrap
Pascal/Delphi Source File
|
1994-08-25
|
12KB
|
244 lines
procedure CopySubStr( Str1: string; start, nrchars: byte; var Str2: string );
assembler;
{ copy part of Str1 (beginning at start for nrchars) to Str2
if start > length of Str1, Str2 will contain a empty string.
if nrchars specifies more characters than remain starting at the
start position, Str2 will contain just that remainder of Str1. }
asm
{ setup }
LDS SI,Str1 { load in DS:SI pointer to str1 }
CLD { string operations forward }
LES DI,Str2 { load in ES:DI pointer to str2 }
MOV AH,[SI] { length str1 --> AH }
AND AH,AH { length str1 = 0? }
JE @null { yes, empty string in Str2 }
MOV BL,[start] { starting position --> BL }
CMP AH,BL { start > length str1? }
JB @null { yes, empty string in Str2 }
{ start + nrchars - 1 > length str1? }
MOV AL,[nrchars] { nrchars --> AL }
MOV DH,AL { nrchars --> DH }
ADD DH,BL { add start }
DEC DH
CMP AH,DH { nrchars > rest of str1? }
JB @rest { yes, copy rest of str1 }
JMP @copy
@null:
MOV AL,0 { return a empty string }
JMP @done
@rest:
SUB AH,BL { length str1 - start }
INC AH
MOV AL,AH
@copy:
MOV CL,AL { how many chars to copy }
XOR CH,CH { clear CH }
XOR BH,BH { clear BH }
ADD SI,BX { starting position }
MOV DX,DI { save pointer to str2 }
INC DI
REP MOVSB { copy part str1 to str2 }
MOV DI,DX { restore pointer to str2 }
@done:
MOV [DI],AL { overwrite length byte of str2 }
@exit:
end { CopySubStr };
procedure StrCopy( var Str1, Str2: string ); assembler;
{ copy str1 to str2 }
asm
LDS SI,Str1 { load in DS:SI pointer to str1 }
CLD { string operations forward }
LES DI,Str2 { load in ES:DI pointer to str2 }
XOR CH,CH { clear CH }
MOV CL,[SI] { length str1 --> CX }
INC CX { include length byte }
REP MOVSB { copy str1 to str2 }
@exit:
end { StrCopy };
function StrPos( var str1, str2: string ): byte; assembler;
{ returns position of the first occurrence of str1 in str2 }
{ return value in AX }
{ str1 - string to search for }
{ str2 - string to search in }
asm
CLD { string operations forward }
LES DI,Str2 { load in ES:DI pointer to str2 }
XOR CH,CH { clear CH }
MOV CL,[DI] { length str2 --> CX }
AND CX,CX { length str2 = 0? }
JZ @Negatief { length str2 = 0, nothing to search in }
INC DI { make DI point to the 1st char of str2 }
LDS SI,Str1 { load in DS:SI pointer to str1 }
LODSB { load in AL length str1 }
AND AL,AL { length str1 = 0? }
JZ @Negatief { length str1 = 0, nothing to search for }
MOV AH,AL { length str1 --> AH }
DEC AH { 1st char need not be compared again }
LODSB { load in AL 1st character of str1 }
@Start:
REPNE SCASB { scan for next occurrence 1st char in str2 }
JNE @Negatief { no success }
CMP CL,AH { length str1 > # chars left in str2 ? }
JB @Negatief { yes, str1 not in str2 }
MOV DX,SI { pointer to 2nd char in str1 --> DX }
MOV BX,CX { number of chars in str2 to go --> BX }
MOV CL,AH { length str1 --> CL }
REPE CMPSB { compare until characters don't match }
JE @Positief { full match }
SUB SI,DX { current SI - prev. SI = # of chars moved }
SUB DI,SI { reconstruct DI }
MOV SI,DX { restore pointer to 2nd char in str1 }
MOV CX,BX { number of chars in str2 to go --> BX }
JMP @Start { scan for next occurrence 1st char in str2 }
@Negatief:
XOR AX,AX { str1 is not in str, result 0 }
JMP @Exit
@Positief:
XOR AH,AH { clear AH }
LES DI,Str2 { load in ES:DI pointer to str2 }
MOV AL,[DI] { length str2 --> AX }
SUB AX,BX { start position of str1 in str2 }
@Exit: { we are finished. }
end { StrPos };
procedure Trim( var Str: string ); assembler;
{ remove leading and trailing white space from str }
asm
{ setup }
LDS SI,Str { load in DS:SI pointer to Str }
MOV AX,DS { Set ES to same segment as DS }
MOV ES,AX { Set ES to same segment as DS }
MOV AL,[SI] { length Str --> AL }
AND AL,AL { length Str = 0? }
JZ @exit { yes, nothing to do }
MOV DI,SI { pointer to Str --> DI }
MOV AH,AL { length Str --> AH }
{ remove trailing white space }
XOR CH,CH { clear CH }
MOV CL,AH { length Str --> CX }
ADD SI,CX { start with last character }
@start1:
MOV AL,[SI] { character --> AL }
CMP AL,20H { no white space }
JA @stop1 { last non-blank character found }
DEC SI { count down SI }
DEC CL { count down CX }
AND CL,CL { more characters left? }
JZ @stop1 { no, done }
JMP @start1 { try again }
@stop1:
AND CL,CL { length Str = 0? }
JZ @done { string is empty, done }
{ look for leading white space }
MOV SI,DI { pointer to Str --> SI }
@start2:
INC SI { next character }
MOV AL,[SI] { character --> AL }
CMP AL,20H { no white space }
JA @stop2 { first non-blank character found }
DEC CL { count down }
AND CL,CL { more characters left? }
JZ @stop2 { no, done }
JMP @start2 { try again }
@stop2:
MOV DX,SI { difference between SI and DI gives }
SUB DX,DI { position first non-blank character }
CMP DX,1 { first character non-blank? }
JE @done { yes, done }
{ remove leading white space }
CLD { string operations forward }
MOV BX,CX { save length Str }
MOV DX,DI { save pointer to Str }
INC DI { don't overwrite length byte of Str }
REP MOVSB { move remaining part of Str }
MOV DI,DX { restore pointer to Str }
MOV CX,BX { restore length Str }
@done:
MOV [DI],CL { overwrite length byte of Str }
@exit:
end { Trim };
procedure RTrim( var Str: string ); assembler;
{ remove trailing white space from str }
asm
{ setup }
LDS SI,Str { load in DS:SI pointer to Str }
MOV AL,[SI] { length Str --> AL }
AND AL,AL { length Str = 0? }
JZ @exit { yes, exit }
MOV DI,SI { pointer to Str --> DI }
MOV AH,AL { length Str --> AH }
{ remove trailing space }
STD { SeT Direction flag --> backwards }
XOR CH,CH { clear CH }
MOV CL,AH { length Str --> CX }
ADD SI,CX { start with last character }
@start:
MOV AL,[SI] { character --> AL }
CMP AL,20H { no white space }
JA @stop { last non-blank character found }
DEC SI { count down }
DEC CL { count down }
AND CL,CL { more characters left? }
JZ @stop { no, done }
JMP @start { try again }
@stop:
MOV [DI],CL { overwrite length byte of Str }
@exit:
end { RTrim };
procedure LTrim( var Str: string ); assembler;
{ remove leading white space from str }
asm
{ setup }
LDS SI,Str { load in DS:SI pointer to Str }
MOV AL,[SI] { length Str --> AL }
AND AL,AL { length Str = 0? }
JZ @exit { yes, nothing to do }
MOV DI,SI { pointer to Str --> DI }
XOR CH,CH { clear CH }
MOV CL,AL { length Str --> CX }
{ look for leading white space }
@start:
INC SI { next character }
MOV AL,[SI] { character --> AL }
CMP AL,20H { no white space }
JA @stop { first non-blank character found }
DEC CL { count down }
AND CL,CL { more characters left? }
JZ @nullstr { no, done }
JMP @start { try again }
@nullstr:
MOV CL,0 { null string }
JMP @done { we're done }
@stop:
MOV DX,SI { difference between SI and DI gives }
SUB DX,DI { position first non-blank character }
CMP DX,1 { first character non-blank? }
JE @exit { yes, exit }
{ remove leading white space }
CLD { string operations forward }
MOV DX,CX { save length Str }
MOV BX,DI { save pointer to Str }
INC DI { don't overwrite length byte of Str }
REP MOVSB { move remaining part of Str }
MOV DI,BX { restore pointer to Str }
MOV CX,DX { restore length Str }
@done:
MOV [DI],CL { overwrite length byte of Str }
@exit:
end { LTrim };
